home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 43 / Amiga Format CD43 (1999)(Future Publishing)(GB)(Track 1 of 2)[!][issue 1999-09].iso / -serious- / hardware / camedia / camedia.c < prev    next >
C/C++ Source or Header  |  1999-06-14  |  34KB  |  1,562 lines
  1. #include <stdlib.h>
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <time.h>
  5.  
  6. #include <dos/dos.h>
  7. #include <exec/exec.h>
  8. #include <devices/serial.h>
  9.  
  10. #include <clib/exec_protos.h>
  11. #include <clib/dos_protos.h>
  12. #include <clib/alib_protos.h>
  13.  
  14. #include <pragma/dos_lib.h>
  15. #include <pragma/exec_lib.h>
  16.  
  17. #include "Camedia.h"
  18.  
  19. struct MsgPort  *SerialMP=NULL;
  20. struct MsgPort  *TimerMP=NULL;
  21. struct IOExtSer *SerialIO=NULL;
  22. struct timerequest *TimerIO=NULL;
  23.  
  24. ULONG WaitMask;
  25. int get_preview=0;
  26. int first_Packet=1;
  27. char error_msg_buffer[256];
  28.  
  29. void clean(int entrypoint) {
  30.     switch(entrypoint) {
  31.         case 100:
  32.         case 101:
  33.             if (TimerIO) {
  34.                CloseDevice((struct IORequest *) TimerIO);
  35.            }
  36.         case 102:
  37.             if (SerialIO) {
  38.                 CloseDevice((struct IORequest *) SerialIO);
  39.             }
  40.         case 103:
  41.             if (TimerIO) {
  42.                 DeleteExtIO((struct IORequest *) TimerIO);
  43.                 TimerIO=NULL;
  44.             }
  45.         case 104:
  46.             if (SerialIO) {
  47.                 DeleteExtIO((struct IORequest *) SerialIO);
  48.                 SerialIO=NULL;
  49.             }
  50.         case 105:
  51.             if (TimerMP) {
  52.                 DeletePort(TimerMP);
  53.                 TimerMP=NULL;
  54.             }
  55.         case 106:
  56.             if (SerialMP) {
  57.                 DeletePort(SerialMP);
  58.                 SerialMP=NULL;
  59.             }
  60.     };
  61. }
  62.  
  63.  
  64. void bootstrap(char *serial_device, int unit, char* error_msg) {
  65.     SerialMP=CreatePort(0,0);
  66.     if (!SerialMP) {
  67.         strcpy(error_msg, "Couldn't do CreateMsgPort() for SerialMP");
  68.         return;
  69.     }
  70.     
  71.     TimerMP=CreatePort(0,0);
  72.     if (!SerialMP) {
  73.         clean(106);
  74.         strcpy(error_msg, "Couldn't do CreateMsgPort() for TimerMP");
  75.         return;
  76.     }
  77.     
  78.     if (!(SerialIO = (struct IOExtSer *) CreateExtIO(SerialMP, sizeof(struct IOExtSer)))) {
  79.         clean(105);
  80.         strcpy(error_msg, "Couldn't do CreateExtIO() for SerialIO");
  81.         return;
  82.     }
  83.     
  84.     if (!(TimerIO = (struct timerequest *) CreateExtIO(TimerMP, sizeof(struct timerequest)))) {
  85.         clean(104);
  86.         strcpy(error_msg, "Couldn't do CreateExtIO() for TimerIO");
  87.         return;
  88.     }
  89.     
  90.     if (OpenDevice(serial_device, (ULONG) unit, (struct IORequest *) SerialIO, 0)) {
  91.         sprintf(error_msg_buffer, "Error, couldn't open %s, unit %d", serial_device, unit);
  92.         clean(103);
  93.         strcpy(error_msg, error_msg_buffer);
  94.         return;
  95.     }
  96.     
  97.     SerialIO->io_RBufLen=2060;
  98.     SerialIO->io_SerFlags &=SERF_XDISABLED | SERF_RAD_BOOGIE;
  99.     SerialIO->IOSer.io_Command = SDCMD_SETPARAMS;
  100.     if (DoIO((struct IORequest *)SerialIO)) {
  101.         sprintf(error_msg_buffer, "Error, couldn't set the read buffer from %s, unit %d to 2060 bytes", serial_device, unit);
  102.         clean(103);
  103.         strcpy(error_msg, error_msg_buffer);
  104.         return;
  105.     }
  106.     
  107.     
  108.     if (OpenDevice(TIMERNAME, UNIT_VBLANK, (struct IORequest *) TimerIO, 0L)) {
  109.         clean(102);
  110.         strcpy(error_msg, "Error, couldn't open timer device");
  111.         return;
  112.     }
  113.  
  114.     WaitMask=SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_F| 1L<<SerialMP->mp_SigBit | 1L<<TimerMP->mp_SigBit;
  115. }
  116.  
  117. void SetSerialSpeed(enum Camera_Speed cam_speed, char* error_msg ) {
  118.     long computer_speed;
  119.     
  120.     switch(cam_speed) {
  121.         case CAMERA_SPEED_9600:
  122.             computer_speed=9600;
  123.             break;
  124.             
  125.         case CAMERA_SPEED_19200:
  126.         case CAMERA_SPEED_INIT:
  127.             computer_speed=19200;
  128.             break;
  129.             
  130.         case CAMERA_SPEED_38400:
  131.             computer_speed=38400;
  132.             break;
  133.             
  134.         case CAMERA_SPEED_57600:
  135.             computer_speed=57600;
  136.             break;
  137.             
  138.         case CAMERA_SPEED_115200:
  139.             computer_speed=115200;
  140.             break;
  141.         
  142.         default:
  143.             strcpy(error_msg, "Unknown Camera speed");
  144.             return;
  145.     }
  146.     
  147.     SerialIO->io_Baud=computer_speed;
  148.     SerialIO->IOSer.io_Command = SDCMD_SETPARAMS;
  149.     if (DoIO((struct IORequest *)SerialIO)) strcpy(error_msg, "Error in SetSerialSpeed");
  150. }
  151.  
  152. void init(enum Camera_Speed cs, char* error_msg ) {
  153.     L1 r;
  154.     int retry=0;
  155.  
  156.     while (retry<MAX_RETRIES) {
  157.  
  158.         SetSerialSpeed(CAMERA_SPEED_INIT, error_msg);
  159.         if (*error_msg!=0) goto init_catch;
  160.         // check speed
  161.         send_L1(Computer_Initialization_Byte, error_msg);
  162.         if (*error_msg!=0) goto init_catch;
  163.         
  164.         read_L1(&r, error_msg);
  165.         if (*error_msg!=0) goto init_catch;
  166.         if (r==Camera_Signature) {
  167.             Set_Comm_Speed(cs, error_msg);
  168.             if (*error_msg!=0) goto init_catch;
  169.             return;
  170.         }                
  171.     
  172.     init_catch:
  173.         printf("got error in init: %s\n", error_msg);
  174.         retry++;
  175.         Delay(200);
  176.     }
  177.     strcpy(error_msg, "Couldn't do init");
  178. }
  179.  
  180.  
  181. void send(L1 *cb, long length, char* error_msg) {
  182.     ULONG result;
  183.     
  184.     SerialIO->IOSer.io_Length  = length;
  185.     SerialIO->IOSer.io_Data    = (APTR) cb;
  186.     SerialIO->IOSer.io_Command = CMD_WRITE;
  187.     
  188.     TimerIO->tr_node.io_Command = TR_ADDREQUEST;
  189.     TimerIO->tr_time.tv_secs=TIMEOUT;
  190.     TimerIO->tr_time.tv_micro=0;
  191.     
  192.     #ifdef comm_debug
  193.         printf("Will send %d bytes:\n", length);
  194.         print_bytes(cb, length);
  195.     #endif
  196.     
  197.     SendIO((struct IORequest *) TimerIO);
  198.     SendIO((struct IORequest *) SerialIO);
  199.     while (1) {
  200.         result=Wait(WaitMask);
  201.         if (CheckIO((struct IORequest *) SerialIO) ) {
  202.             WaitIO((struct IORequest *) SerialIO);
  203.             if (!CheckIO((struct IORequest *) TimerIO) ) AbortIO((struct IORequest *) TimerIO);
  204.             WaitIO((struct IORequest *) TimerIO);
  205.             #ifdef comm_debug
  206.                 printf("Send was ok\n\n");
  207.             #endif
  208.             return;
  209.         }
  210.         if (CheckIO((struct IORequest *) TimerIO) ) {
  211.             // Timeout
  212.             WaitIO((struct IORequest *) TimerIO);
  213.             if (!CheckIO((struct IORequest *) SerialIO) )AbortIO((struct IORequest *) SerialIO);
  214.             WaitIO((struct IORequest *) SerialIO);
  215.             strcpy(error_msg, "timeout error");
  216.             return;
  217.         }
  218.         if (result & (SIGBREAKF_CTRL_C|SIGBREAKF_CTRL_F)) {
  219.             if (!CheckIO((struct IORequest *) SerialIO) )AbortIO((struct IORequest *) SerialIO);
  220.             WaitIO((struct IORequest *) SerialIO);
  221.             if (!CheckIO((struct IORequest *) TimerIO) ) AbortIO((struct IORequest *) TimerIO);
  222.             WaitIO((struct IORequest *) TimerIO);
  223.             strcpy(error_msg, "User sent CTRL_C or F");
  224.             return;
  225.         }
  226.     }
  227. }
  228.  
  229. __inline void send_L1(L1 b, char* error_msg) {
  230.     send(&b,1, error_msg);
  231. }
  232.  
  233. __inline void send_L2(L2 s, char* error_msg) {
  234.     L2 n;
  235.     
  236.     n=SetL2(s);
  237.     send((L1 *) &n, 2, error_msg);
  238. }
  239.  
  240. void read(L1 *cb, long max_size, char* error_msg) {
  241.     ULONG result;
  242.  
  243.     #ifdef comm_debug
  244.        printf("Would like to receive %d bytes\n", max_size);
  245.     #endif
  246.    
  247.     SerialIO->IOSer.io_Length  = max_size;
  248.     SerialIO->IOSer.io_Data    = (APTR) cb;
  249.     SerialIO->IOSer.io_Command = CMD_READ;
  250.  
  251.     TimerIO->tr_node.io_Command = TR_ADDREQUEST;
  252.     TimerIO->tr_time.tv_secs=TIMEOUT;
  253.     TimerIO->tr_time.tv_micro=0;
  254.  
  255.     SendIO((struct IORequest *) TimerIO);
  256.     SendIO((struct IORequest *) SerialIO);
  257.     
  258.     while (1) {
  259.         result=Wait(WaitMask);
  260.         if (CheckIO((struct IORequest *)SerialIO)) {
  261.             WaitIO((struct IORequest *) SerialIO);
  262.             if (!CheckIO((struct IORequest *) TimerIO) ) AbortIO((struct IORequest *) TimerIO);
  263.             WaitIO((struct IORequest *) TimerIO);
  264.             
  265.             #ifdef comm_debug
  266.                 printf("Received %d bytes:\n", SerialIO->IOSer.io_Actual);
  267.                 print_bytes(cb, SerialIO->IOSer.io_Actual);
  268.                 printf("\n");
  269.             #endif
  270.             
  271.             if (SerialIO->IOSer.io_Actual!=max_size) {
  272.                 strcpy(error_msg, "Couldn't read enough");
  273.                 return;
  274.             }            
  275.             return;
  276.         }
  277.         
  278.         if (CheckIO((struct IORequest *) TimerIO) ){
  279.             // Timeout
  280.             WaitIO((struct IORequest *) TimerIO);
  281.             if (!CheckIO((struct IORequest *) SerialIO) )AbortIO((struct IORequest *) SerialIO);
  282.             WaitIO((struct IORequest *) SerialIO);
  283.             strcpy(error_msg, "timeout error");
  284.             return;
  285.         }
  286.          
  287.         if (result & (SIGBREAKF_CTRL_C|SIGBREAKF_CTRL_F)) {
  288.             if (!CheckIO((struct IORequest *) SerialIO) )AbortIO((struct IORequest *) SerialIO);
  289.             WaitIO((struct IORequest *) SerialIO);
  290.             if (!CheckIO((struct IORequest *) TimerIO) ) AbortIO((struct IORequest *) TimerIO);
  291.             WaitIO((struct IORequest *) TimerIO);
  292.             strcpy(error_msg, "User sent CTRL_C or F");
  293.             return;
  294.         }
  295.     }
  296. }
  297.  
  298. __inline void read_L1(L1 *v, char* error_msg) {
  299.     read(v, 1, error_msg);
  300. } 
  301.  
  302. __inline void read_L2(L2 *v, char* error_msg) {
  303.     read((L1 *) v, 2, error_msg);
  304.     *v=SetL2(*v);
  305. }
  306.  
  307. __inline void read_L4(L4 *v, char* error_msg) {
  308.     read((L1 *) v, 4, error_msg);
  309.     *v=SetL4(*v);
  310. }
  311.  
  312. __inline L2 checksum(L1 *start, L1 *end) {
  313.     L1 *i; L2 cs=0;
  314.     for (i=start; i<end; i++)
  315.         cs=cs+(L1) *i;
  316.  
  317.     return (L2) (cs &0xffff);
  318. }
  319.  
  320.  
  321. void SetIntegerRegister(enum Command_0 Register, L4 Value, char* error_msg) {
  322.         struct Command_0_Packet cmd;
  323.         L1 v; 
  324.           int retries;
  325.  
  326.         cmd.Packet_type=Packet_Command;
  327.            if (first_Packet) {
  328.                    cmd.Packet_subtype=Packet_Subtype_First_Command;
  329.                first_Packet=0;
  330.         }
  331.            else {
  332.                    cmd.Packet_subtype=Packet_Subtype_Not_First_Command;
  333.         }
  334.           cmd.Length_of_data=SetL2(6);
  335.         cmd.Command_Code=0;
  336.         cmd.Register_Number=Register;
  337.           cmd.NewValue=SetL4(Value);
  338.         cmd.checksum=SetL2(checksum((L1 *) &(cmd.Command_Code), (L1 *) &(cmd.checksum)));
  339.  
  340.         #ifdef debug
  341.               print_bytes((L1 *)&cmd, sizeof(struct Command_0_Packet));
  342.           #endif
  343.  
  344.          retries=0;
  345.           while (retries<MAX_RETRIES) {
  346.                 send((L1 *) &cmd, sizeof(struct Command_0_Packet), error_msg);
  347.                 if (*error_msg!=0) return;
  348.                 read_L1(&v, error_msg);
  349.                 if (*error_msg!=0) return;
  350.                 if (v==Camera_Positive_Achnowledgement) return;
  351.                   else if (v==Camera_Unable_to_Execute_Command) retries++;
  352.                 else {
  353.                     strcpy(error_msg, "Got unexpected msg from camera");
  354.                     return;
  355.                 }
  356.           }
  357. }
  358.  
  359.  
  360. void ReadIntegerRegister(enum Command_1 Register, L4 *value, char* error_msg) {
  361.     struct Command_1_Packet cmd;
  362.     L2 cs, ccs;
  363.     int retries=0;
  364.     L1 bb[10];
  365.     L4 *L4b;
  366.     
  367.     cmd.Packet_type=Packet_Command;
  368.     if (first_Packet) {
  369.         cmd.Packet_subtype=Packet_Subtype_First_Command;
  370.         first_Packet=0;
  371.     }
  372.     else {
  373.         cmd.Packet_subtype=Packet_Subtype_Not_First_Command;
  374.     }
  375.     
  376.     cmd.Length_of_data=0x0200;
  377.     cmd.Command_Code=0x01;
  378.     cmd.Register_Number=Register;
  379.     cmd.checksum=(Register+1)<<8;
  380.         
  381.     #ifdef debug
  382.         print_bytes((L1 *) &cmd, sizeof(struct Command_1_Packet));
  383.     #endif
  384.  
  385.     send((L1 *) &cmd, sizeof(struct Command_1_Packet), error_msg);
  386.     /* get packet */
  387.     while (retries<MAX_RETRIES) {
  388.         read(bb, 10, error_msg);
  389.         // check consistency;
  390.         
  391.         L4b=(L4 *) &bb[0];
  392.         if (*L4b!=0x03000400) {
  393.             strcpy(error_msg, "Got unexpected data from camera");
  394.             return;
  395.         }
  396.         
  397.         *value= (L4) ((bb[7]<<24) + (bb[6]<<16) + (bb[5]<<8) + bb[4]);
  398.         cs=(L2) ((bb[9]<<8) + bb[8]);
  399.         ccs=(L4) (bb[4]+bb[5]+bb[6]+bb[7]);
  400.         if (cs!=ccs) {
  401.             printf("Checksum (=%x) is not calculated checksum (=%x)\n", cs, ccs);
  402.             retries++;
  403.             send_L1(Computer_Negative_Achnowledgement, error_msg);
  404.             if (*error_msg!=0) return;
  405.         } else {
  406.             send_L1(Computer_Positive_Achnowledgement, error_msg);
  407.             return; // return anyway
  408.         }
  409.     }
  410.     strcpy(error_msg, "Retry Error in ReadIntegerRegister()");
  411. }
  412.  
  413.  
  414. void TakeAction(enum Action_Code action, L1 arg, char* error_msg) {
  415.           /* struct and in this case struct Command_2_Packet has a special behavior.
  416.            When declaring an element, which takes more then one single byte
  417.            like L2 or L4, the structure will set the offset to an even number.
  418.            Example:
  419.  
  420.                 Offset:
  421.                         struct Command_2_Packet {
  422.                 0            L1 Packet_type;
  423.                 1            L1 Packet_subtype;
  424.                 2            L2 Length_of_data;
  425.  
  426.                 4            L1 Command_Code;
  427.                 5            L1 Action_Code;
  428.                 6            L1 single_byte;
  429.  
  430.                 8            L2 checksum;
  431.                    }
  432.  
  433.              As You see, the offset 8 at checksum is an even address. So the
  434.           memory at offset 7 will not be used. 
  435.  
  436.           That is normaly no problem, as long as the structre is used in memory.
  437.           But in this case, the structre will be sent to the camera as a stream of
  438.           bytes. That means also the unused byte at offset 7 will be sent, which is
  439.           of course not part of the camera protocol. That's why I can't send it directly,
  440.              I have to send it in two parts (0..6 and 7..8).
  441.  
  442.              Why does the compiler this automatic offset changing? The reason is simple.
  443.           The 68000 family cpu (and mnay others too) can't access to odd addresses.
  444.           If You try, You will get an alert (=Guru message).
  445.         */
  446.  
  447.     struct Command_2_Packet cmd;
  448.     L1 bb[2]; L2 cs;
  449.  
  450.     cmd.Packet_type=Packet_Command;
  451.     if (first_Packet) {
  452.         cmd.Packet_subtype=Packet_Subtype_First_Command;
  453.         first_Packet=0;
  454.    } else {
  455.        cmd.Packet_subtype=Packet_Subtype_Not_First_Command;
  456.    }
  457.  
  458.     cmd.Length_of_data=0x0300;
  459.     cmd.Command_Code=0x02;
  460.     cmd.Action_Code=action;
  461.     if (action==AC_Set_Protection_State && arg!=0) cmd.single_byte=1;
  462.     else cmd.single_byte=0;
  463.     //cs=checksum((L1 *) &(cmd.Command_Code), (L1 *) (&(cmd.single_byte)+1));
  464.     cs=(2+action+cmd.single_byte);
  465.  
  466.     send((L1 *) &cmd, sizeof(struct Command_2_Packet)-3, error_msg);
  467.     if (*error_msg!=0) return;
  468.     send_L2(cs, error_msg);
  469.     if (*error_msg!=0) return;
  470.  
  471.     read(bb, 2, error_msg);
  472.     if (*error_msg!=0) return;
  473.     if (bb[0]!=Camera_Positive_Achnowledgement) {
  474.         strcpy(error_msg, "Error in TakeAction, no Camera ACK");
  475.         return;
  476.     }
  477.     if (bb[1]!=Camara_Action_Complete_Notification)
  478.         strcpy(error_msg, "Error in TakeAction, no action complete notification");
  479.     return;
  480. }
  481.  
  482.  
  483. void ReadVDataRegister(enum Command_4 Register, L1 *ret, L4 *total_size, char* error_msg) {
  484.     struct Command_4_Packet cmd;
  485.     L1 *bb, local_seq_number=0;
  486.     L2 size, cs, ccs;
  487.     int retry;
  488.     L1 minibuffer[4];
  489.     
  490.     bb=ret;
  491.     *total_size=0;
  492.     
  493.     cmd.Packet_type=Packet_Command;
  494.     if (first_Packet) {
  495.         cmd.Packet_subtype=Packet_Subtype_First_Command;
  496.         first_Packet=0;
  497.     }
  498.     else {
  499.         cmd.Packet_subtype=Packet_Subtype_Not_First_Command;
  500.     }
  501.     cmd.Length_of_data=0x0200;
  502.     cmd.Command_Code=4;
  503.     cmd.Register_Number=Register;
  504.     //cmd.checksum=SetL2(checksum((L1 *) &(cmd.Command_Code), (L1 *) &(cmd.checksum)));
  505.     cmd.checksum=(4+Register)<<8;
  506.  
  507.     send((L1 *) &cmd, sizeof(struct Command_4_Packet), error_msg);
  508.     if (*error_msg!=0) return;
  509.     
  510.     /* here, I should be able to receive one or many Data-Packages */
  511.     retry=0;
  512.     do {
  513.         read(minibuffer, 4, error_msg);
  514.         if (*error_msg!=0) return;
  515.         if (minibuffer[0]!=Packet_Last_in_Seq && minibuffer[0]!=Packet_Not_Last_in_Seq) {
  516.             strcpy(error_msg, "Got unexpected msg from camera in ReadVDataRegister()");
  517.             return;
  518.         }
  519.         
  520.         if (minibuffer[1]!=local_seq_number) {
  521.             strcpy(error_msg, "Packet seq doesn't match with internal seq");
  522.             return;
  523.         }
  524.  
  525.         size=(minibuffer[3]<<8) + minibuffer[2];
  526.         if (size>2048) {
  527.             strcpy(error_msg, "wrong size");
  528.             return;
  529.         }
  530.         if (retry==0) {
  531.             *total_size=*total_size+(L4) size;
  532.         }
  533.         read(bb, size+2, error_msg);
  534.         if (*error_msg!=0) return;
  535.         cs=(bb[size+1]<<8) + bb[size];
  536.         ccs=checksum((L1 *) bb, (L1 *) (bb+size));
  537.         if (cs!=ccs) {
  538.             printf("wrong checksum  (got=%x, calculated=%x)\n", cs, ccs);
  539.             retry++;
  540.         }
  541.         if (retry==0) {
  542.             /* send ACK */
  543.             send_L1(Computer_Positive_Achnowledgement, error_msg);
  544.             if (*error_msg!=0) return;
  545.             if (minibuffer[0]==Packet_Last_in_Seq) return;
  546.             bb+=size;
  547.             local_seq_number++;
  548.         
  549.         } else {
  550.             /* send NAK */
  551.             send_L1(Computer_Negative_Achnowledgement, error_msg);
  552.             if (*error_msg!=0) return;
  553.             retry=0;
  554.         }
  555.     } while (1);
  556. }
  557.  
  558. #ifdef comm_debug
  559.  
  560. void print_bytes(L1 *p, long len) {
  561.     long i, j, oldi;
  562.     
  563.     if (len<32) {
  564.         // print all
  565.         for (i=0;i<len;) {
  566.             oldi=i;
  567.             j=i+16;
  568.             if (j>len) j=len;
  569.             
  570.             for (;i<j;i++) {
  571.                 printf("%5d ", i);
  572.             }
  573.             printf("\n");
  574.             for (i=oldi;i<j;i++) {
  575.                 printf("%5x ", (int) p[i]);
  576.             }
  577.             printf("\n");
  578.         }
  579.         printf("\n\n");
  580.     } else {
  581.         // print two parts
  582.         
  583.         for (i=0;i<16;) {
  584.             oldi=i;
  585.             j=i+16;
  586.                         
  587.             for (;i<j;i++) {
  588.                 printf("%5d ", i);
  589.             }
  590.             printf("\n");
  591.             for (i=oldi;i<j;i++) {
  592.                 printf("%5x ", (int) p[i]);
  593.             }
  594.             printf("\n");
  595.         }
  596.         printf("\n");
  597.         
  598.         for (i=len-16;i<len;) {
  599.             oldi=i;
  600.             j=i+16;
  601.             if (j>len) j=len;
  602.             
  603.             for (;i<j;i++) {
  604.                 printf("%5d ", i);
  605.             }
  606.             printf("\n");
  607.             for (i=oldi;i<j;i++) {
  608.                 printf("%5x ", (int) p[i]);
  609.             }
  610.             printf("\n");
  611.         }
  612.         printf("\n\n");
  613.     }
  614. }
  615.  
  616. #endif
  617.  
  618. void save_Frame(int framenumber, char *name, char *comment, char* error_msg) {
  619.     BPTR file;
  620.     struct Command_4_Packet cmd;
  621.     L1 local_seq_number=0;
  622.     L2 size, cs, ccs;
  623.     int retry, not_all_read=1;
  624.     L1 minibuffer[4];
  625.     L1 buffer[2050];
  626.     
  627.     file=Open(name, MODE_NEWFILE);
  628.     if (file==NULL) {
  629.         strcpy(error_msg, "Couldn't open file");
  630.         return;
  631.     }
  632.     
  633.     SetIntegerRegister(Cmd_Set_Current_Frame_Number, (L1) framenumber, error_msg);
  634.     if (*error_msg!=0) {
  635.         Close(file);
  636.         DeleteFile(name);
  637.         return;
  638.     }
  639.     
  640.     // ask camera to send data
  641.  
  642.     cmd.Packet_type=Packet_Command;
  643.     if (first_Packet) {
  644.         cmd.Packet_subtype=Packet_Subtype_First_Command;
  645.         first_Packet=0;
  646.     }
  647.     else {
  648.         cmd.Packet_subtype=Packet_Subtype_Not_First_Command;
  649.     }
  650.     cmd.Length_of_data=0x0200;
  651.     cmd.Command_Code=4;
  652.     cmd.Register_Number=Cmd_Get_Current_Frame;
  653.     cmd.checksum=(4+Cmd_Get_Current_Frame)<<8;
  654.  
  655.     send((L1 *) &cmd, sizeof(struct Command_4_Packet), error_msg);
  656.     if (*error_msg!=0) {
  657.         printf("%s\n", error_msg);
  658.         Close(file);
  659.         DeleteFile(name);
  660.         strcpy(error_msg, "ReadVDRegister:Error during sending Packet");
  661.         return;
  662.     }
  663.  
  664.  
  665.     // read data and save them            
  666.     retry=0;
  667.     do {
  668.         // read a bit
  669.         read(minibuffer, 4, error_msg);
  670.         if (*error_msg!=0) {
  671.             Close(file);
  672.             DeleteFile(name);
  673.             return;
  674.         }
  675.  
  676.         if (minibuffer[0]!=Packet_Last_in_Seq && minibuffer[0]!=Packet_Not_Last_in_Seq) {
  677.             Close(file);
  678.             DeleteFile(name);
  679.             strcpy(error_msg, "Got unexpected msg from camera");
  680.             return;
  681.         }        
  682.         
  683.         if (minibuffer[1]!=local_seq_number) {
  684.             printf("Packet seq#=%d doesn't match with internal seq#%d\n", minibuffer[1], local_seq_number);
  685.             Close(file);
  686.             DeleteFile(name);
  687.             strcpy(error_msg, "Packet seq# doesn't match with internal seq#");
  688.             return;
  689.         }
  690.  
  691.         size=(minibuffer[3]<<8) + minibuffer[2];
  692.         if (size>2048) {
  693.             Close(file);
  694.             DeleteFile(name);
  695.             strcpy(error_msg, "wrong size (bigger then 2048");
  696.             return;
  697.         }
  698.         
  699.         read(buffer, size+2, error_msg);
  700.         if (*error_msg!=0) goto catch_save_Frame;
  701.         
  702.         cs=(buffer[size+1]<<8) + buffer[size];
  703.         ccs=checksum((L1 *) buffer, (L1 *) (buffer+size));
  704.         if (cs!=ccs) {
  705.             printf("wrong checksum  (got=%x, calculated=%x)\n", cs, ccs);
  706.             retry++;
  707.         }
  708.         if (retry==0) {
  709.             /* send ACK */
  710.             send_L1(Computer_Positive_Achnowledgement, error_msg);
  711.             if (*error_msg!=0) goto catch_save_Frame;
  712.             if (minibuffer[0]==Packet_Last_in_Seq) not_all_read=0;
  713.             local_seq_number++;
  714.         
  715.         } else {
  716.             /* send NAK */
  717.             send_L1(Computer_Negative_Achnowledgement, error_msg);
  718.             if (*error_msg!=0) goto catch_save_Frame;
  719.             retry=0;
  720.         }
  721.         goto skip_catch_save_Frame;
  722.     catch_save_Frame:
  723.         Close(file);
  724.         DeleteFile(name);
  725.         return;
  726.         
  727.     skip_catch_save_Frame:
  728.             
  729.         // save a bit    
  730.         if (-1==Write(file, (void *) buffer, size)) {
  731.             Close(file);
  732.             DeleteFile(name);
  733.             strcpy(error_msg, "Error during writing the file");
  734.             return;
  735.         }            
  736.     }
  737.     while (not_all_read!=0);
  738.     Close(file);
  739.     if (comment!=NULL) SetComment(name, comment);
  740.     return;
  741. }
  742.  
  743.  
  744. void save_Thumbnail(int framenumber, char *name, char *comment, char* error_msg) {
  745.  
  746.     long *size=0;
  747.     L1 buffer[4060];
  748.     BPTR file;
  749.     
  750.     
  751.     file=Open(name, MODE_NEWFILE);
  752.     if (file==NULL) {
  753.         strcpy(error_msg, "Couldn't open file");
  754.         return;
  755.     }
  756.         
  757.     SetIntegerRegister(Cmd_Set_Current_Frame_Number, (L1) framenumber, error_msg);
  758.     if (*error_msg!=0) {
  759.         Close(file);
  760.         DeleteFile(name);
  761.         return;
  762.     }
  763.  
  764.     ReadVDataRegister(Cmd_Get_Current_Thumbnail, (L1 *) buffer, (L4 *) size, error_msg);
  765.     if (*error_msg!=0) {
  766.         printf("%s\n", error_msg);
  767.         strcpy(error_msg, "An error occured in ReadVDataRegister(Cmd_Get_Current_Frame, (L1 *) buffer, size);\n");
  768.         return;
  769.     }
  770.     if (-1==Write(file, (void *) buffer, *size)) {
  771.         Close(file);
  772.         DeleteFile(name);
  773.         strcpy(error_msg, "Error during writing the file");
  774.         return;
  775.     }
  776.     Close(file);
  777.     if (comment!=NULL) SetComment(name, comment);
  778.     return;
  779. }
  780.  
  781.  
  782. void Set_Resolution(Resolution re, char* error_msg) {
  783.     int retries=0;
  784.     MACRO_Set_Integer(Cmd_Set_Resolution, (L4) re, error_msg);
  785. }
  786.  
  787.  
  788. void Set_Clock(time_t c, char* error_msg) {
  789.     int retries=0;
  790.     MACRO_Set_Integer(Cmd_Set_Clock, (L4) c, error_msg);
  791. }
  792.  
  793.  
  794. void Set_Shutter_Speed(long ss, char* error_msg) {
  795.     int retries=0;
  796.     MACRO_Set_Integer(Cmd_Set_Shutter_Speed, (L4) ss, error_msg);
  797. }
  798.  
  799.  
  800. void Set_Aperture(enum Aperture a, char* error_msg) {
  801.     int retries=0;
  802.     MACRO_Set_Integer(Cmd_Set_Aperture, (L4) a, error_msg);
  803. }
  804.  
  805.  
  806. void Set_Color_Mode(enum Color_Mode cm, char* error_msg) {
  807.     int retries=0;
  808.     MACRO_Set_Integer(Cmd_Set_Color_Mode, (L4) cm, error_msg);
  809. }
  810.  
  811.  
  812. void Set_Flash_Mode(enum Flash_Mode fm, char* error_msg) {
  813.     int retries=0;
  814.     MACRO_Set_Integer(Cmd_Set_Flash_Mode, (L4) fm, error_msg);
  815. }
  816.  
  817.  
  818. void Set_Comm_Speed(enum Camera_Speed cs, char* error_msg) {
  819.     SetIntegerRegister(Cmd_Set_Comm_Speed, (L4) cs, error_msg);
  820.     if (*error_msg!=0) return;
  821.     Delay(5); // wait 0.5 seconds so camera can prepare for the change
  822.     SetSerialSpeed(cs, error_msg);
  823. }
  824.  
  825.  
  826. void Set_Bright_And_Contrast(enum Bright_Contrast bc, char* error_msg) {
  827.     int retries=0;
  828.     MACRO_Set_Integer(Cmd_Set_Bright_And_Contrast, (L4) bc, error_msg);
  829. }
  830.  
  831.  
  832. void Set_White_Balance(enum White_Balance wb, char* error_msg) {
  833.     int retries=0;
  834.     MACRO_Set_Integer(Cmd_Set_White_Balance, (L4) wb, error_msg);
  835. }
  836.  
  837.  
  838. void Set_Autoshut_on_Host_Timer(int aoht, char* error_msg) {
  839.     int retries=0;
  840.     MACRO_Set_Integer(Cmd_Set_Autoshut_on_Host_Timer, (L4) aoht, error_msg);
  841. }
  842.  
  843.  
  844. void Set_Autoshut_on_Field_Timer(int asoft, char* error_msg) {
  845.     int retries=0;
  846.     MACRO_Set_Integer(Cmd_Set_Autoshut_on_Field_Timer, (L4) asoft, error_msg);
  847. }
  848.  
  849.  
  850. void Set_LED(enum LED_Mode lm, char* error_msg) {
  851.     int retries=0;
  852.     MACRO_Set_Integer(Cmd_Set_LED, (L4) lm, error_msg);
  853. }
  854.  
  855.  
  856. void Set_Lens_Mode(enum Lens_Mode lm, char* error_msg) {
  857.     int retries=0;
  858.     MACRO_Set_Integer(Cmd_Set_Lens_Mode, (L4) lm, error_msg);
  859. }
  860.  
  861.  
  862. void Set_Date_Format(enum Date_Format df, char* error_msg) {
  863.     int retries=0;
  864.     MACRO_Set_Integer(Cmd_Set_Date_Format, (L4) df, error_msg);
  865. }
  866.  
  867.  
  868. void Set_Exp_Meter(enum Exp_Meter em, char* error_msg) {
  869.     int retries=0;
  870.     MACRO_Set_Integer(Cmd_Set_Exp_Meter, (L4) em, error_msg);
  871. }
  872.  
  873.  
  874. void Set_Optical_Mode(int AEL_WBL, int Fisheye, int Wide, int Digital_Zoom, int BAW, char* error_msg) {
  875.     L4 r=0;
  876.     int retries=0;
  877.     
  878.     if (AEL_WBL) r+=0x1;
  879.     if (Fisheye) r+=0x2;
  880.     if (Wide) r+=0x4;
  881.     if (Digital_Zoom) r+=0x8;
  882.     if (BAW) {r+=0x10}
  883.     
  884.     MACRO_Set_Integer(Cmd_Set_Optical_Mode, (L4) r, error_msg);
  885. }
  886.  
  887.  
  888. void Get_Resolution(enum Resolution *re, char* error_msg) {
  889.     L4 r;
  890.     int retries=0;
  891.     
  892.     MACRO_Get_FI_Integer(Cmd_Get_Resolution, error_msg);
  893.     if (*error_msg!=0) return;
  894.  
  895.     switch (r) {
  896.         case Standard_Resolution:
  897.         case High_Resolution:
  898.         case Extended_Resolution:
  899.             *re=(Resolution) r;
  900.             return;
  901.         default:
  902.             *re=Unknown_Resolution;
  903.     }
  904. }
  905.  
  906.  
  907. void Get_Clock(time_t *c, char* error_msg) {
  908.     L4 r;
  909.     int retries=0;
  910.     
  911.     MACRO_Get_FI_Integer(Cmd_Get_Clock, error_msg);
  912.     *c=(time_t) r;
  913. }
  914.  
  915.  
  916. void Get_Shutter_Speed(long *ss, char* error_msg) {
  917.     L4 r;
  918.     int retries=0;
  919.     
  920.     MACRO_Get_FI_Integer(Cmd_Get_Shutter_Speed, error_msg);
  921.     *ss=(long) r;
  922. }
  923.  
  924.  
  925. void Get_Aperture(enum Aperture *a, char* error_msg) {
  926.     L4 r;
  927.     int retries=0;
  928.     
  929.     MACRO_Get_FI_Integer(Cmd_Get_Aperture, error_msg);
  930.  
  931.     switch (r) {
  932.         case Low_Aperture:
  933.         case Midium_Aperture:
  934.         case High_Aperture:
  935.             *a=(Aperture) r;
  936.             break;
  937.         default:
  938.             *a=Unknown_Aperture;
  939.     }
  940. }
  941.  
  942.  
  943. void Get_Color_Mode(enum Color_Mode *cm, char* error_msg) {
  944.     L4 r;
  945.     int retries=0;
  946.     
  947.     MACRO_Get_FI_Integer(Cmd_Get_Color_Mode, error_msg);
  948.  
  949.     switch (r) {
  950.         case Color_Color_Mode:
  951.         case BAW_Color_Mode:
  952.             *cm=(Color_Mode) r;
  953.             break;
  954.         default:
  955.             *cm=Unknown_Color_Mode;;
  956.     }
  957. }
  958.  
  959.  
  960. void Get_Flash_Mode(enum Flash_Mode *fm, char* error_msg) {
  961.     L4 r;
  962.     int retries=0;
  963.     
  964.     MACRO_Get_FI_Integer(Cmd_Get_Flash_Mode, error_msg);
  965.  
  966.     switch (r) {
  967.         case Auto_Flash_Mode:
  968.         case Force_Flash_Mode:
  969.         case Off_Flash_Mode:
  970.         case Anti_Red_Eye_Flash_Mode:
  971.         case Slow_Sync_Flash_Mode:
  972.             *fm=(Flash_Mode) r;
  973.             break;
  974.             
  975.         default:
  976.             *fm=Unknown_Flash_Mode;
  977.     }
  978. }
  979.  
  980.  
  981. void Get_Num_of_Frames_Taken(int *noft, char* error_msg) {
  982.     L4 r;
  983.     int retries=0;
  984.     
  985.     MACRO_Get_FI_Integer(Cmd_Get_Num_of_Frames_Taken, error_msg);
  986.     *noft=(int) r;
  987. }
  988.  
  989.  
  990. void Get_Num_of_Frames_Left(int *nofl, char* error_msg) {
  991.     L4 r;
  992.     int retries=0;
  993.     
  994.     MACRO_Get_FI_Integer(Cmd_Get_Num_of_Frames_Left, error_msg);
  995.     *nofl=(int) r;
  996. }
  997.  
  998.  
  999. void Get_Length_of_Frame(int framenumber, long *length, char* error_msg) {
  1000.     L4 r;
  1001.     int retries=0;
  1002.     get_preview=0;
  1003.     
  1004.     MACRO_Get_FD_Integer(framenumber, Cmd_Get_Length_of_Current_Frame, error_msg);
  1005.     *length=(long) r;
  1006. }
  1007.  
  1008.  
  1009. void Get_Length_of_Thumbnail(int framenumber, long *length, char* error_msg) {
  1010.     L4 r;
  1011.     int retries=0;
  1012.     get_preview=0;
  1013.     
  1014.     MACRO_Get_FD_Integer(framenumber, Cmd_Get_Length_of_Current_Thumbnail, error_msg);
  1015.     *length=(long) r;
  1016. }
  1017.  
  1018.  
  1019. void Get_Battery_Capacity(int *bc, char* error_msg) {
  1020.     L4 r;
  1021.     int retries=0;
  1022.     
  1023.     MACRO_Get_FI_Integer(Cmd_Get_Battery_Capacity, error_msg);
  1024.     *bc=(int) r;
  1025. }
  1026.  
  1027.  
  1028. void Get_Comm_Speed(enum Camera_Speed *cs, char* error_msg) {
  1029.     L4 r;
  1030.     int retries=0;
  1031.     
  1032.     MACRO_Get_FI_Integer(Cmd_Get_Comm_Speed, error_msg);
  1033.  
  1034.     r=r& 0xff;
  1035.     switch(r) {
  1036.         case CAMERA_SPEED_9600:
  1037.         case CAMERA_SPEED_19200:
  1038.         case CAMERA_SPEED_38400:
  1039.         case CAMERA_SPEED_57600:
  1040.         case CAMERA_SPEED_115200:
  1041.             *cs=(Camera_Speed) r;
  1042.             break;
  1043.         default:
  1044.             *cs=CAMERA_SPEED_Unknown;
  1045.     }
  1046. }
  1047.  
  1048.  
  1049. void Get_Bright_And_Contrast(enum Bright_Contrast *bc, char* error_msg) {
  1050.     L4 r;
  1051.     int retries=0;
  1052.     
  1053.     MACRO_Get_FI_Integer(Cmd_Get_Bright_And_Contrast, error_msg);
  1054.  
  1055.     switch(r) {
  1056.         case Normal_Bright_Contrast:
  1057.         case More_Bright_Bright_Contrast:
  1058.         case Less_Bright_Bright_Contrast:
  1059.         case More_Contrast_Bright_Contrast:
  1060.         case Less_Contrast_Bright_Contrast:
  1061.             *bc=(Bright_Contrast) r;
  1062.             break;
  1063.         
  1064.         default:
  1065.             *bc=Unknown_Bright_Contrast;
  1066.             break;
  1067.     }
  1068. }
  1069.  
  1070.  
  1071. void Get_White_Balance(enum White_Balance *wb, char* error_msg) {
  1072.     L4 r;
  1073.     int retries=0;
  1074.     
  1075.     MACRO_Get_FI_Integer(Cmd_Get_White_Balance, error_msg);
  1076.     
  1077.     switch(r) {
  1078.         case Auto_White_Balance:
  1079.         case Skylight_White_Balance:
  1080.         case Fluoresent_White_Balance:
  1081.         case Thungsten_White_Balance:
  1082.         case Cloudy_White_Balance:
  1083.             *wb=(White_Balance) r;
  1084.             break;
  1085.         
  1086.         default:
  1087.             *wb=Unknown_White_Balance;
  1088.             break;
  1089.     }
  1090. }
  1091.  
  1092.  
  1093. void Get_Autoshut_on_Host_Timer(int *asoht, char* error_msg) {
  1094.     L4 r;
  1095.     int retries=0;
  1096.     
  1097.     MACRO_Get_FI_Integer(Cmd_Get_Autoshut_on_Field_Timer, error_msg);
  1098.     *asoht=(int) r;
  1099. }
  1100.  
  1101.  
  1102. void Get_Autoshut_on_Field_Timer(int *asoft, char* error_msg) {
  1103.     L4 r;
  1104.     int retries=0;
  1105.     
  1106.     MACRO_Get_FI_Integer(Cmd_Get_Autoshut_on_Field_Timer, error_msg);
  1107.     *asoft=(int) r;
  1108. }
  1109.  
  1110.  
  1111. void Get_Available_Memory_Left(long *aml, char* error_msg) {
  1112.     L4 r;
  1113.     int retries=0;
  1114.     
  1115.     MACRO_Get_FI_Integer(Cmd_Get_Available_Memory_Left, error_msg);
  1116.     *aml=(int) r;
  1117. }
  1118.  
  1119.  
  1120. void Get_Lens_Mode(enum Lens_Mode *lm, char* error_msg) {
  1121.     L4 r;
  1122.     int retries=0;
  1123.  
  1124.     MACRO_Get_FI_Integer(Cmd_Get_Lens_Mode, error_msg);
  1125.  
  1126.     switch(r) {
  1127.         case Macro_Lens_Mode:
  1128.         case Normal_Lens_Mode:
  1129.         case Infinity_Fisheye_Lens_Mode:
  1130.             *lm=(Lens_Mode) r;
  1131.             break;
  1132.         
  1133.         default:
  1134.             *lm=Unknown_Lens_Mode;
  1135.             break;
  1136.     }
  1137. }
  1138.  
  1139. void Get_LCD_Brightness(int *lb, char* error_msg) {
  1140.     L4 r;
  1141.     int retries=0;
  1142.     
  1143.     MACRO_Get_FI_Integer(Cmd_Get_LCD_Brightness, error_msg);
  1144.     *lb=(int) r;
  1145. }
  1146.  
  1147.  
  1148. void Get_LCD_Autoshut_Timer(int *lat, char* error_msg) {
  1149.     L4 r;
  1150.     int retries=0;
  1151.     
  1152.     MACRO_Get_FI_Integer(Cmd_Get_LCD_Autoshut_Timer, error_msg);
  1153.     *lat=(int) r;
  1154. }
  1155.  
  1156.  
  1157. void Get_Protect_State_of_Frame(int framenumber, int *psof, char* error_msg) {
  1158.     L4 r;
  1159.     int retries=0;
  1160.     get_preview=0;
  1161.     
  1162.     MACRO_Get_FD_Integer(framenumber, Cmd_Get_Protect_State_of_Current_Frame, error_msg);
  1163.     *psof=(int) r;
  1164. }
  1165.  
  1166.  
  1167. void Get_Date_Format(enum Date_Format *df, char* error_msg) {
  1168.     L4 r;
  1169.     int retries=0;
  1170.     
  1171.     MACRO_Get_FI_Integer(Cmd_Get_Date_Format, error_msg);
  1172.  
  1173.     switch(r) {
  1174.         case YY_MM_DD_Date_Format:
  1175.         case DD_MM_HH_Date_Format:
  1176.             *df=(Date_Format) r;
  1177.             break;
  1178.         
  1179.         default:
  1180.             *df=Unknown_Date_Format;
  1181.             break;
  1182.     }
  1183. }
  1184.  
  1185.  
  1186. void Get_Exp_Meter(enum Exp_Meter *em, char* error_msg) {
  1187.     L4 r;
  1188.     int retries=0;
  1189.     
  1190.     MACRO_Get_FI_Integer(Cmd_Get_Exp_Meter, error_msg);
  1191.  
  1192.     switch(r) {
  1193.         case Center_weighted_Exp_Meter:
  1194.         case Spot_Exp_Meter:
  1195.         case Multi_Element_Matrix_Exp_Meter:
  1196.             *em=(Exp_Meter) r;
  1197.             break;
  1198.         
  1199.         default:
  1200.             *em=Unknown_Exp_Meter;
  1201.             break;
  1202.     }
  1203. }
  1204.  
  1205.  
  1206. void Get_Optical_Mode(int *AEL_WBL, int *Fisheye, int *Wide, int *Digital_Zoom, int *BAW, char* error_msg) {
  1207.     L4 r;
  1208.     int retries=0;
  1209.     
  1210.     MACRO_Get_FI_Integer(Cmd_Get_Optical_Mode, error_msg);
  1211.     
  1212.     *AEL_WBL=(r & 0x1);
  1213.     *Fisheye=(r & 0x2);
  1214.     *Wide=(r & 0x4);
  1215.     *Digital_Zoom=(r & 0x8);
  1216.     *BAW=(r & 0x10);
  1217. }
  1218.  
  1219.  
  1220. void Get_Frame(int framenumber, UBYTE *buffer, long *size, char* error_msg) {
  1221.     int retries=0;
  1222.     get_preview=0;
  1223.     
  1224.     MACRO_Get_FD_VData(framenumber, Cmd_Get_Current_Frame, buffer, size, error_msg);
  1225. }
  1226.  
  1227.  
  1228. void Get_Thumbnail(int framenumber, UBYTE *buffer, long *size, char* error_msg)  {
  1229.     int retries=0;
  1230.     get_preview=0;
  1231.     
  1232.     MACRO_Get_FD_VData(framenumber, Cmd_Get_Current_Thumbnail, buffer, size, error_msg);
  1233. }
  1234.  
  1235.  
  1236. void Get_Camera_ID(UBYTE *buffer, long *size, char* error_msg) {
  1237.     int retries=0;
  1238.         
  1239.     MACRO_Get_FI_VData(Cmd_Get_Camera_ID, buffer, size, error_msg);
  1240. }
  1241.  
  1242.  
  1243. void Get_Serial_Number(UBYTE *buffer, long *size, char* error_msg) {
  1244.     int retries=0;
  1245.     
  1246.     MACRO_Get_FI_VData(Cmd_Get_Serial_Number, buffer, size, error_msg);
  1247. }
  1248.  
  1249.  
  1250. void Get_Version(UBYTE *buffer, long *size, char* error_msg) {
  1251.     int retries=0;
  1252.     
  1253.     MACRO_Get_FI_VData(Cmd_Get_Version, buffer, size, error_msg);
  1254. }
  1255.  
  1256.  
  1257. void Get_Model(char *string, long *size, char* error_msg) {
  1258.     int retries=0;
  1259.     
  1260.     MACRO_Get_FI_VData(Cmd_Get_Model, string, size, error_msg);
  1261. }
  1262.  
  1263.  
  1264. /* not supported by many cameras */
  1265. void Get_Audio_Data(UBYTE *buffer, long *size, char* error_msg) {
  1266.     int retries=0;
  1267.  
  1268.     MACRO_Get_FI_VData(Cmd_Get_Audio_Data, buffer, size, error_msg);
  1269. }
  1270.  
  1271.  
  1272. void Get_Camera_Summery_Data(enum Resolution *re, int *LCD_Brightness, int *Frames_Taken, char* error_msg) {
  1273.     int retries=0;
  1274.     L4 buffer[8];
  1275.     long *size=NULL;
  1276.         
  1277.     MACRO_Get_FI_VData(Cmd_Get_Camera_Summery_Data, buffer, size, error_msg);
  1278.  
  1279.     *re=(Resolution)SetL4(buffer[0]);
  1280.     *LCD_Brightness=(int)SetL4(buffer[1]);
  1281.     *Frames_Taken=(int) SetL4(buffer[2]);
  1282. }
  1283.  
  1284.  
  1285. void Get_Picture_Summery_Data(int framenumber, long *AudioDataLength, enum Resolution *re, int *ProtectionState, time_t *TimeDate, char* error_msg) {
  1286.     int retries=0;
  1287.     L4 buffer[8];
  1288.     long *size=NULL;
  1289.     get_preview=0;
  1290.     
  1291.     MACRO_Get_FD_VData(framenumber, Cmd_Get_Picture_Summery_Data, buffer, size, error_msg);
  1292.     if (*error_msg!=0) return;
  1293.  
  1294.     if ((*size)!=32) {
  1295.         strcpy(error_msg, "wrong size of data packet");
  1296.         return;
  1297.     }
  1298.     *AudioDataLength=(long)SetL4(buffer[2]);
  1299.  
  1300.     switch(SetL4(buffer[3])) {
  1301.         case Standard_Resolution:
  1302.         case High_Resolution:
  1303.         case Extended_Resolution:
  1304.             *re=(Resolution)SetL4(buffer[3]);
  1305.             break;
  1306.     
  1307.         default:
  1308.             *re=Unknown_Resolution;
  1309.             break;
  1310.     }
  1311.  
  1312.     *ProtectionState=(int) SetL4(buffer[4]);
  1313.     *TimeDate=(time_t) SetL4(buffer[5]);
  1314.  
  1315. }
  1316.  
  1317.  
  1318. void Get_Manufacturer(char *string, long *size, char* error_msg) {
  1319.     int retries=0;
  1320.     
  1321.     MACRO_Get_FI_VData(Cmd_Get_Manufacturer, string, size, error_msg);
  1322. }
  1323.  
  1324.  
  1325. void Get_Preview(UBYTE *buffer, long *size, char* error_msg)  {
  1326.     
  1327.     
  1328.     TakeAction(AC_Take_Preview_Snapshot, 0, error_msg);
  1329.     if (*error_msg!=0) {
  1330.         printf("%s\n", error_msg);
  1331.         strcpy(error_msg, "An error occured in TakeAction(AC_Take_Preview_Snapshot, 0);");
  1332.         return;
  1333.     }
  1334.     
  1335.     if (get_preview==0) {
  1336.     
  1337.         SetIntegerRegister(Cmd_Set_Current_Frame_Number, (L1) 0, error_msg);
  1338.         if (*error_msg!=0) {
  1339.             printf("%s\n", error_msg);
  1340.             strcpy(error_msg, "An error occured in SetIntegerRegister(Cmd_Set_Current_Frame_Number, (L1) 0);");
  1341.             return;
  1342.         }
  1343.     }
  1344.     
  1345.     get_preview=1;
  1346.     
  1347.     ReadVDataRegister(Cmd_Get_Current_Frame, (L1 *) buffer, (L4 *) size, error_msg);
  1348.     if (*error_msg!=0) {
  1349.         printf("%s\n", error_msg);
  1350.         strcpy(error_msg, "An error occured in ReadVDataRegister(Cmd_Get_Current_Frame, (L1 *) buffer, size);\n");
  1351.     }
  1352.     return;
  1353. }
  1354.  
  1355.  
  1356. char* dump_Resolution(enum Resolution r) {
  1357.     switch (r) {
  1358.         case Standard_Resolution:
  1359.             return "Standard";
  1360.         
  1361.         case High_Resolution:
  1362.             return "High";
  1363.         
  1364.         case Extended_Resolution:
  1365.             return "Extended";
  1366.         
  1367.         default:
  1368.             return "Unknown";
  1369.     }
  1370. }
  1371.  
  1372.  
  1373. char* dump_Aperture(enum Aperture a) {
  1374.     switch(a) {
  1375.         case Low_Aperture:
  1376.             return "Low";
  1377.         
  1378.         case Midium_Aperture:
  1379.             return "Midium";
  1380.         
  1381.         case High_Aperture:
  1382.             return "High";
  1383.         
  1384.         default:
  1385.             return "Unknown";
  1386.     }
  1387. }
  1388.  
  1389.  
  1390. char* dump_Color_Mode(enum Color_Mode cm) {
  1391.     switch(cm) {
  1392.         case Color_Color_Mode:
  1393.             return "Color";
  1394.         
  1395.         case BAW_Color_Mode:
  1396.             return "B&W";
  1397.         
  1398.         default:
  1399.             return "Unknown";
  1400.     }
  1401. }
  1402.  
  1403.  
  1404. char* dump_Flash_Mode(enum Flash_Mode fm) {
  1405.     switch(fm) {
  1406.         case Auto_Flash_Mode:
  1407.             return "Auto";
  1408.         
  1409.         case Force_Flash_Mode:
  1410.             return "Force";
  1411.             
  1412.         case Off_Flash_Mode:
  1413.             return "Off";
  1414.         
  1415.         case Anti_Red_Eye_Flash_Mode:
  1416.             return "Anti_Red_Eye";
  1417.         
  1418.         case Slow_Sync_Flash_Mode:
  1419.             return "Slow_Sync";
  1420.             
  1421.         default:
  1422.             return "Unknown";
  1423.     }
  1424. }    
  1425.  
  1426.  
  1427. char* dump_Camera_Speed(enum Camera_Speed cs) {
  1428.     switch (cs) {
  1429.         case CAMERA_SPEED_INIT:
  1430.             return "init-speed (=19200)";
  1431.         
  1432.         case CAMERA_SPEED_9600:
  1433.             return "9600";
  1434.             
  1435.         case CAMERA_SPEED_19200:
  1436.             return "19200";
  1437.         
  1438.         case CAMERA_SPEED_38400:
  1439.             return "38400";
  1440.         
  1441.         case CAMERA_SPEED_57600:
  1442.             return "57600";
  1443.         
  1444.         case CAMERA_SPEED_115200:
  1445.             return "115200";
  1446.             
  1447.         default:
  1448.             return "Unknown";
  1449.     }
  1450. }
  1451.  
  1452.  
  1453. char* dump_Bright_Contrast(enum Bright_Contrast bc) {
  1454.     switch (bc) {
  1455.         case Normal_Bright_Contrast:
  1456.             return "Normal_Bright";
  1457.         
  1458.         case More_Bright_Bright_Contrast:
  1459.             return "More_Bright";
  1460.         
  1461.         case Less_Bright_Bright_Contrast:
  1462.             return "Less_Bright";
  1463.             
  1464.         case More_Contrast_Bright_Contrast:
  1465.             return "More_Contrast";
  1466.         
  1467.         case Less_Contrast_Bright_Contrast:
  1468.             return "Less_Contrast";
  1469.             
  1470.         default:
  1471.             return "Unknown";
  1472.     }
  1473. }
  1474.  
  1475.  
  1476. char* dump_White_Balance(enum White_Balance wb) {
  1477.     switch (wb) {
  1478.         case Auto_White_Balance:
  1479.             return "Auto";
  1480.         
  1481.         case Skylight_White_Balance:
  1482.             return "Skylight";
  1483.         
  1484.         case Fluoresent_White_Balance:
  1485.             return "Fluoresent";
  1486.         
  1487.         case Thungsten_White_Balance:
  1488.             return "Thungsten";
  1489.         
  1490.         case Cloudy_White_Balance:
  1491.             return "Cloudy";
  1492.         
  1493.         default:
  1494.             return "Unknown";
  1495.     }
  1496. }
  1497.  
  1498.  
  1499. char* dump_Lens_Mode(enum Lens_Mode lm) {
  1500.     switch (lm) {
  1501.         case Macro_Lens_Mode:
  1502.             return "Macro";
  1503.         
  1504.         case Normal_Lens_Mode:
  1505.             return "Normal";
  1506.         
  1507.         case Infinity_Fisheye_Lens_Mode:
  1508.             return "Infinity_Fisheye";
  1509.         
  1510.         default:
  1511.             return "Unknown";
  1512.     }
  1513. }
  1514.  
  1515.  
  1516. char* dump_Date_Format(enum Date_Format df) {
  1517.     switch (df) {
  1518.         case YY_MM_DD_Date_Format:
  1519.             return "YY MM DD";
  1520.  
  1521.         case DD_MM_HH_Date_Format:
  1522.             return "DD MM HH";
  1523.         
  1524.         default:
  1525.             return "Unknown";
  1526.     }
  1527. }
  1528.  
  1529.  
  1530. char* dump_Exp_Meter(enum Exp_Meter em) {
  1531.     switch (em) {
  1532.         case Center_weighted_Exp_Meter:
  1533.             return "Center_weighted";
  1534.         
  1535.         case Spot_Exp_Meter:
  1536.             return "Spot";
  1537.         
  1538.         case Multi_Element_Matrix_Exp_Meter:
  1539.             return "Multi_Element_Matrix";
  1540.         
  1541.         default:
  1542.             return "Unknown";
  1543.     }
  1544. }
  1545.  
  1546.  
  1547. char* dump_LED_Mode(enum LED_Mode lm) {
  1548.     switch (lm) {
  1549.         case Off_LED_Mode:
  1550.             return "Off";
  1551.         
  1552.         case On_LED_Mode:
  1553.             return "On";
  1554.         
  1555.         case Blink_LED_Mode:
  1556.             return "Blink";
  1557.         
  1558.         default:
  1559.             return "Unknown";
  1560.     }
  1561. }
  1562.